# -*- coding: utf-8 -*-
from gi.repository import Gio
from gi.repository import GObject


class Colorspace:
    """This enumeration defines the color spaces that are supported by
the gdk-pixbuf library.  Currently only RGB is supported."""
    RGB = 0


class InterpType:
    """This enumeration describes the different interpolation modes that
 can be used with the scaling functions. @GDK_INTERP_NEAREST is
 the fastest scaling method, but has horrible quality when
 scaling down. @GDK_INTERP_BILINEAR is the best choice if you
 aren't sure what to choose, it has a good speed/quality balance.

 <note>
	Cubic filtering is missing from the list; hyperbolic
	interpolation is just as fast and results in higher quality.
 </note>"""
    NEAREST = 0
    TILES = 1
    BILINEAR = 2
    HYPER = 3
PIXBUF_FEATURES_H = r"""1"""
PIXBUF_MAGIC_NUMBER = r"""1197763408"""
PIXBUF_MAJOR = r"""2"""
PIXBUF_MICRO = r"""11"""
PIXBUF_MINOR = r"""36"""
PIXBUF_VERSION = r"""2.36.11"""
PIXDATA_HEADER_LENGTH = r"""24"""


class PixbufAlphaMode:
    """These values can be passed to
gdk_pixbuf_xlib_render_to_drawable_alpha() to control how the alpha
channel of an image should be handled.  This function can create a
bilevel clipping mask (black and white) and use it while painting
the image.  In the future, when the X Window System gets an alpha
channel extension, it will be possible to do full alpha
compositing onto arbitrary drawables.  For now both cases fall
back to a bilevel clipping mask."""
    BILEVEL = 0
    FULL = 1


class PixbufError:
    """An error code in the #GDK_PIXBUF_ERROR domain. Many gdk-pixbuf
operations can cause errors in this domain, or in the #G_FILE_ERROR
domain."""
    CORRUPT_IMAGE = 0
    INSUFFICIENT_MEMORY = 1
    BAD_OPTION = 2
    UNKNOWN_TYPE = 3
    UNSUPPORTED_OPERATION = 4
    FAILED = 5
    INCOMPLETE_ANIMATION = 6


class PixbufRotation:
    """The possible rotations which can be passed to gdk_pixbuf_rotate_simple().
To make them easier to use, their numerical values are the actual degrees."""
    NONE = 0
    COUNTERCLOCKWISE = 90
    UPSIDEDOWN = 180
    CLOCKWISE = 270


class PixdataDumpType:
    """An enumeration which is used by gdk_pixdata_to_csource() to
determine the form of C source to be generated. The three values
@GDK_PIXDATA_DUMP_PIXDATA_STREAM, @GDK_PIXDATA_DUMP_PIXDATA_STRUCT
and @GDK_PIXDATA_DUMP_MACROS are mutually exclusive, as are
@GDK_PIXBUF_DUMP_GTYPES and @GDK_PIXBUF_DUMP_CTYPES. The remaining
elements are optional flags that can be freely added."""
    PIXDATA_STREAM = 0
    PIXDATA_STRUCT = 1
    MACROS = 2
    GTYPES = 0
    CTYPES = 256
    STATIC = 512
    CONST = 1024
    RLE_DECODER = 65536


class PixdataType:
    """An enumeration containing three sets of flags for a #GdkPixdata struct:
one for the used colorspace, one for the width of the samples and one
for the encoding of the pixel data."""
    COLOR_TYPE_RGB = 1
    COLOR_TYPE_RGBA = 2
    COLOR_TYPE_MASK = 255
    SAMPLE_WIDTH_8 = 65536
    SAMPLE_WIDTH_MASK = 983040
    ENCODING_RAW = 16777216
    ENCODING_RLE = 33554432
    ENCODING_MASK = 251658240

def pixbuf_error_quark():
    """    
    @returns: 
    @rtype: GLib.Quark
    """
    return object


class Pixbuf(GObject.Object, Gio.Icon, Gio.LoadableIcon):
    """This is the main structure in the gdk-pixbuf library.  It is
used to represent images.  It contains information about the
image's pixel data, its color space, bits per sample, width and
height, and the rowstride (the number of bytes between the start of
one row and the start of the next)."""
    
    def __init__(self, colorspace=None, has_alpha=None, bits_per_sample=None, width=None, height=None):
        """        Creates a new #GdkPixbuf structure and allocates a buffer for it.  The
        buffer has an optimal rowstride.  Note that the buffer is not cleared;
        you will have to fill it completely yourself.
        @param colorspace: Color space for image
        @param has_alpha: Whether the image should have transparency information
        @param bits_per_sample: Number of bits per color sample
        @param width: Width of image in pixels, must be > 0
        @param height: Height of image in pixels, must be > 0
        @type colorspace: Colorspace
        @type has_alpha: bool
        @type bits_per_sample: int
        @type width: int
        @type height: int
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new(colorspace=None, has_alpha=None, bits_per_sample=None, width=None, height=None):
        """        Creates a new #GdkPixbuf structure and allocates a buffer for it.  The
        buffer has an optimal rowstride.  Note that the buffer is not cleared;
        you will have to fill it completely yourself.
        @param colorspace: Color space for image
        @param has_alpha: Whether the image should have transparency information
        @param bits_per_sample: Number of bits per color sample
        @param width: Width of image in pixels, must be > 0
        @param height: Height of image in pixels, must be > 0
        @type colorspace: Colorspace
        @type has_alpha: bool
        @type bits_per_sample: int
        @type width: int
        @type height: int
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new_from_bytes(data=None, colorspace=None, has_alpha=None, bits_per_sample=None, width=None, height=None, rowstride=None):
        """        Creates a new #GdkPixbuf out of in-memory readonly image data.
        Currently only RGB images with 8 bits per sample are supported.
        This is the #GBytes variant of gdk_pixbuf_new_from_data().
        @param data: Image data in 8-bit/sample packed format inside a #GBytes
        @param colorspace: Colorspace for the image data
        @param has_alpha: Whether the data has an opacity channel
        @param bits_per_sample: Number of bits per sample
        @param width: Width of the image in pixels, must be > 0
        @param height: Height of the image in pixels, must be > 0
        @param rowstride: Distance in bytes between row starts
        @type data: GLib.Bytes
        @type colorspace: Colorspace
        @type has_alpha: bool
        @type bits_per_sample: int
        @type width: int
        @type height: int
        @type rowstride: int
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new_from_data(data=None, colorspace=None, has_alpha=None, bits_per_sample=None, width=None, height=None, rowstride=None, destroy_fn=None, destroy_fn_data=None):
        """        Creates a new #GdkPixbuf out of in-memory image data.  Currently only RGB
        images with 8 bits per sample are supported.
        
        Since you are providing a pre-allocated pixel buffer, you must also
        specify a way to free that data.  This is done with a function of
        type #GdkPixbufDestroyNotify.  When a pixbuf created with is
        finalized, your destroy notification function will be called, and
        it is its responsibility to free the pixel array.
        
        See also gdk_pixbuf_new_from_bytes().
        @param data: Image data in 8-bit/sample packed format
        @param colorspace: Colorspace for the image data
        @param has_alpha: Whether the data has an opacity channel
        @param bits_per_sample: Number of bits per sample
        @param width: Width of the image in pixels, must be > 0
        @param height: Height of the image in pixels, must be > 0
        @param rowstride: Distance in bytes between row starts
        @param destroy_fn: Function used to free the data when the pixbuf's reference count drops to zero, or %NULL if the data should not be freed
        @param destroy_fn_data: Closure data to pass to the destroy notification function
        @type colorspace: Colorspace
        @type has_alpha: bool
        @type bits_per_sample: int
        @type width: int
        @type height: int
        @type rowstride: int
        @type destroy_fn: PixbufDestroyNotify
        @type destroy_fn_data: gpointer
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new_from_file(filename=None):
        """        Creates a new pixbuf by loading an image from a file.  The file format is
        detected automatically. If %NULL is returned, then @error will be set.
        Possible errors are in the #GDK_PIXBUF_ERROR and #G_FILE_ERROR domains.
        @param filename: Name of file to load, in the GLib file name encoding
        @type filename: str
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new_from_file_at_scale(filename=None, width=None, height=None, preserve_aspect_ratio=None):
        """        Creates a new pixbuf by loading an image from a file.  The file format is
        detected automatically. If %NULL is returned, then @error will be set.
        Possible errors are in the #GDK_PIXBUF_ERROR and #G_FILE_ERROR domains.
        The image will be scaled to fit in the requested size, optionally preserving
        the image's aspect ratio.
        
        When preserving the aspect ratio, a @width of -1 will cause the image
        to be scaled to the exact given height, and a @height of -1 will cause
        the image to be scaled to the exact given width. When not preserving
        aspect ratio, a @width or @height of -1 means to not scale the image
        at all in that dimension. Negative values for @width and @height are
        allowed since 2.8.
        @param filename: Name of file to load, in the GLib file name encoding
        @param width: The width the image should have or -1 to not constrain the width
        @param height: The height the image should have or -1 to not constrain the height
        @param preserve_aspect_ratio: %TRUE to preserve the image's aspect ratio
        @type filename: str
        @type width: int
        @type height: int
        @type preserve_aspect_ratio: bool
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new_from_file_at_size(filename=None, width=None, height=None):
        """        Creates a new pixbuf by loading an image from a file.
        The file format is detected automatically. If %NULL is returned, then
        @error will be set. Possible errors are in the #GDK_PIXBUF_ERROR and
        #G_FILE_ERROR domains.
        
        The image will be scaled to fit in the requested size, preserving
        the image's aspect ratio. Note that the returned pixbuf may be smaller
        than @width x @height, if the aspect ratio requires it. To load
        and image at the requested size, regardless of aspect ratio, use
        gdk_pixbuf_new_from_file_at_scale().
        @param filename: Name of file to load, in the GLib file name encoding
        @param width: The width the image should have or -1 to not constrain the width
        @param height: The height the image should have or -1 to not constrain the height
        @type filename: str
        @type width: int
        @type height: int
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new_from_inline(data_length=None, data=None, copy_pixels=None):
        """        Create a #GdkPixbuf from a flat representation that is suitable for
        storing as inline data in a program. This is useful if you want to
        ship a program with images, but don't want to depend on any
        external files.
        
        gdk-pixbuf ships with a program called [gdk-pixbuf-csource][gdk-pixbuf-csource],
        which allows for conversion of #GdkPixbufs into such a inline representation.
        In almost all cases, you should pass the `--raw` option to
        `gdk-pixbuf-csource`. A sample invocation would be:
        
        |[
         gdk-pixbuf-csource --raw --name=myimage_inline myimage.png
        ]|
        
        For the typical case where the inline pixbuf is read-only static data,
        you don't need to copy the pixel data unless you intend to write to
        it, so you can pass %FALSE for @copy_pixels.  (If you pass `--rle` to
        `gdk-pixbuf-csource`, a copy will be made even if @copy_pixels is %FALSE,
        so using this option is generally a bad idea.)
        
        If you create a pixbuf from const inline data compiled into your
        program, it's probably safe to ignore errors and disable length checks,
        since things will always succeed:
        |[
        pixbuf = gdk_pixbuf_new_from_inline (-1, myimage_inline, FALSE, NULL);
        ]|
        
        For non-const inline data, you could get out of memory. For untrusted
        inline data located at runtime, you could have corrupt inline data in
        addition.
        @param data_length: Length in bytes of the @data argument or -1 to    disable length checks
        @param data: Byte data containing a    serialized #GdkPixdata structure
        @param copy_pixels: Whether to copy the pixel data, or use direct pointers               @data for the resulting pixbuf
        @type data_length: int
        @type copy_pixels: bool
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new_from_resource(resource_path=None):
        """        Creates a new pixbuf by loading an image from an resource.
        
        The file format is detected automatically. If %NULL is returned, then
        @error will be set.
        @param resource_path: the path of the resource file
        @type resource_path: str
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new_from_resource_at_scale(resource_path=None, width=None, height=None, preserve_aspect_ratio=None):
        """        Creates a new pixbuf by loading an image from an resource.
        
        The file format is detected automatically. If %NULL is returned, then
        @error will be set.
        
        The image will be scaled to fit in the requested size, optionally
        preserving the image's aspect ratio. When preserving the aspect ratio,
        a @width of -1 will cause the image to be scaled to the exact given
        height, and a @height of -1 will cause the image to be scaled to the
        exact given width. When not preserving aspect ratio, a @width or
        @height of -1 means to not scale the image at all in that dimension.
        
        The stream is not closed.
        @param resource_path: the path of the resource file
        @param width: The width the image should have or -1 to not constrain the width
        @param height: The height the image should have or -1 to not constrain the height
        @param preserve_aspect_ratio: %TRUE to preserve the image's aspect ratio
        @type resource_path: str
        @type width: int
        @type height: int
        @type preserve_aspect_ratio: bool
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new_from_stream(stream=None, cancellable=None):
        """        Creates a new pixbuf by loading an image from an input stream.
        
        The file format is detected automatically. If %NULL is returned, then
        @error will be set. The @cancellable can be used to abort the operation
        from another thread. If the operation was cancelled, the error
        %G_IO_ERROR_CANCELLED will be returned. Other possible errors are in
        the #GDK_PIXBUF_ERROR and %G_IO_ERROR domains.
        
        The stream is not closed.
        @param stream: a #GInputStream to load the pixbuf from
        @param cancellable: optional #GCancellable object, %NULL to ignore
        @type stream: Gio.InputStream
        @type cancellable: Gio.Cancellable
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new_from_stream_at_scale(stream=None, width=None, height=None, preserve_aspect_ratio=None, cancellable=None):
        """        Creates a new pixbuf by loading an image from an input stream.
        
        The file format is detected automatically. If %NULL is returned, then
        @error will be set. The @cancellable can be used to abort the operation
        from another thread. If the operation was cancelled, the error
        %G_IO_ERROR_CANCELLED will be returned. Other possible errors are in
        the #GDK_PIXBUF_ERROR and %G_IO_ERROR domains.
        
        The image will be scaled to fit in the requested size, optionally
        preserving the image's aspect ratio.
        
        When preserving the aspect ratio, a @width of -1 will cause the image to be
        scaled to the exact given height, and a @height of -1 will cause the image
        to be scaled to the exact given width. If both @width and @height are
        given, this function will behave as if the smaller of the two values
        is passed as -1.
        
        When not preserving aspect ratio, a @width or @height of -1 means to not
        scale the image at all in that dimension.
        
        The stream is not closed.
        @param stream: a #GInputStream to load the pixbuf from
        @param width: The width the image should have or -1 to not constrain the width
        @param height: The height the image should have or -1 to not constrain the height
        @param preserve_aspect_ratio: %TRUE to preserve the image's aspect ratio
        @param cancellable: optional #GCancellable object, %NULL to ignore
        @type stream: Gio.InputStream
        @type width: int
        @type height: int
        @type preserve_aspect_ratio: bool
        @type cancellable: Gio.Cancellable
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new_from_stream_finish(async_result=None):
        """        Finishes an asynchronous pixbuf creation operation started with
        gdk_pixbuf_new_from_stream_async().
        @param async_result: a #GAsyncResult
        @type async_result: Gio.AsyncResult
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def new_from_xpm_data(data=None):
        """        Creates a new pixbuf by parsing XPM data in memory.  This data is commonly
        the result of including an XPM file into a program's C source.
        @param data: Pointer to inline XPM data.
        @returns: Newly created Pixbuf
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def calculate_rowstride(colorspace=None, has_alpha=None, bits_per_sample=None, width=None, height=None):
        """        Calculates the rowstride that an image created with those values would
        have. This is useful for front-ends and backends that want to sanity
        check image values without needing to create them.
        @param colorspace: Color space for image
        @param has_alpha: Whether the image should have transparency information
        @param bits_per_sample: Number of bits per color sample
        @param width: Width of image in pixels, must be > 0
        @param height: Height of image in pixels, must be > 0
        @type colorspace: Colorspace
        @type has_alpha: bool
        @type bits_per_sample: int
        @type width: int
        @type height: int
        @returns: the rowstride for the given values, or -1 in case of error.
        @rtype: int
        """
        return object
    @staticmethod
    def from_pixdata(pixdata=None, copy_pixels=None):
        """        Converts a #GdkPixdata to a #GdkPixbuf. If @copy_pixels is %TRUE or
        if the pixel data is run-length-encoded, the pixel data is copied into
        newly-allocated memory; otherwise it is reused.
        @param pixdata: a #GdkPixdata to convert into a #GdkPixbuf.
        @param copy_pixels: whether to copy raw pixel data; run-length encoded     pixel data is always copied.
        @type pixdata: Pixdata
        @type copy_pixels: bool
        @returns: a new #GdkPixbuf.
        @rtype: Pixbuf
        """
        return object
    @staticmethod
    def get_file_info(filename=None, width=None, height=None):
        """        Parses an image file far enough to determine its format and size.
        @param filename: The name of the file to identify.
        @param width: Return location for the width of the     image, or %NULL
        @param height: Return location for the height of the     image, or %NULL
        @type filename: str
        @type width: int
        @type height: int
        @returns: A #GdkPixbufFormat describing
    the image format of the file or %NULL if the image format wasn't
    recognized. The return value is owned by #GdkPixbuf and should
    not be freed.
        @rtype: PixbufFormat
        """
        return object
    @staticmethod
    def get_file_info_async(filename=None, cancellable=None, callback=None, user_data=None):
        """        Asynchronously parses an image file far enough to determine its
        format and size.
        
        For more details see gdk_pixbuf_get_file_info(), which is the synchronous
        version of this function.
        
        When the operation is finished, @callback will be called in the
        main thread. You can then call gdk_pixbuf_get_file_info_finish() to
        get the result of the operation.
        @param filename: The name of the file to identify
        @param cancellable: optional #GCancellable object, %NULL to ignore
        @param callback: a #GAsyncReadyCallback to call when the file info is available
        @param user_data: the data to pass to the callback function
        @type filename: str
        @type cancellable: Gio.Cancellable
        @type callback: Gio.AsyncReadyCallback
        @type user_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def get_file_info_finish(async_result=None, width=None, height=None):
        """        Finishes an asynchronous pixbuf parsing operation started with
        gdk_pixbuf_get_file_info_async().
        @param async_result: a #GAsyncResult
        @param width: Return location for the width of the image, or %NULL
        @param height: Return location for the height of the image, or %NULL
        @type async_result: Gio.AsyncResult
        @type width: int
        @type height: int
        @returns: A #GdkPixbufFormat describing the image
    format of the file or %NULL if the image format wasn't
    recognized. The return value is owned by GdkPixbuf and should
    not be freed.
        @rtype: PixbufFormat
        """
        return object
    @staticmethod
    def get_formats():
        """        Obtains the available information about the image formats supported
        by GdkPixbuf.
        @returns: A list of #GdkPixbufFormats describing the supported image formats. The list should be freed when it is no longer needed, but the structures themselves are owned by #GdkPixbuf and should not be freed.
        @rtype: GLib.SList
        """
        return object
    @staticmethod
    def new_from_stream_async(stream=None, cancellable=None, callback=None, user_data=None):
        """        Creates a new pixbuf by asynchronously loading an image from an input stream.
        
        For more details see gdk_pixbuf_new_from_stream(), which is the synchronous
        version of this function.
        
        When the operation is finished, @callback will be called in the main thread.
        You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation.
        @param stream: a #GInputStream from which to load the pixbuf
        @param cancellable: optional #GCancellable object, %NULL to ignore
        @param callback: a #GAsyncReadyCallback to call when the pixbuf is loaded
        @param user_data: the data to pass to the callback function
        @type stream: Gio.InputStream
        @type cancellable: Gio.Cancellable
        @type callback: Gio.AsyncReadyCallback
        @type user_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def new_from_stream_at_scale_async(stream=None, width=None, height=None, preserve_aspect_ratio=None, cancellable=None, callback=None, user_data=None):
        """        Creates a new pixbuf by asynchronously loading an image from an input stream.
        
        For more details see gdk_pixbuf_new_from_stream_at_scale(), which is the synchronous
        version of this function.
        
        When the operation is finished, @callback will be called in the main thread.
        You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation.
        @param stream: a #GInputStream from which to load the pixbuf
        @param width: the width the image should have or -1 to not constrain the width
        @param height: the height the image should have or -1 to not constrain the height
        @param preserve_aspect_ratio: %TRUE to preserve the image's aspect ratio
        @param cancellable: optional #GCancellable object, %NULL to ignore
        @param callback: a #GAsyncReadyCallback to call when the pixbuf is loaded
        @param user_data: the data to pass to the callback function
        @type stream: Gio.InputStream
        @type width: int
        @type height: int
        @type preserve_aspect_ratio: bool
        @type cancellable: Gio.Cancellable
        @type callback: Gio.AsyncReadyCallback
        @type user_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def save_to_stream_finish(async_result=None):
        """        Finishes an asynchronous pixbuf save operation started with
        gdk_pixbuf_save_to_stream_async().
        @param async_result: a #GAsyncResult
        @type async_result: Gio.AsyncResult
        @returns: %TRUE if the pixbuf was saved successfully, %FALSE if an error was set.
        @rtype: bool
        """
        return object
    
    def add_alpha(self, substitute_color=None, r=None, g=None, b=None):
        """        Takes an existing pixbuf and adds an alpha channel to it.
        If the existing pixbuf already had an alpha channel, the channel
        values are copied from the original; otherwise, the alpha channel
        is initialized to 255 (full opacity).
        
        If @substitute_color is %TRUE, then the color specified by (@r, @g, @b) will be
        assigned zero opacity. That is, if you pass (255, 255, 255) for the
        substitute color, all white pixels will become fully transparent.
        @param substitute_color: Whether to set a color to zero opacity.  If this is %FALSE, then the (@r, @g, @b) arguments will be ignored.
        @param r: Red value to substitute.
        @param g: Green value to substitute.
        @param b: Blue value to substitute.
        @type substitute_color: bool
        @type r: guint8
        @type g: guint8
        @type b: guint8
        @returns: A newly-created pixbuf with a reference count of 1.
        @rtype: Pixbuf
        """
        return object
    
    def apply_embedded_orientation(self):
        """        Takes an existing pixbuf and checks for the presence of an
        associated "orientation" option, which may be provided by the
        jpeg loader (which reads the exif orientation tag) or the
        tiff loader (which reads the tiff orientation tag, and
        compensates it for the partial transforms performed by
        libtiff). If an orientation option/tag is present, the
        appropriate transform will be performed so that the pixbuf
        is oriented correctly.
        @returns: A newly-created pixbuf, %NULL if not enough memory could be allocated for it, or a reference to the input pixbuf (with an increased reference count).
        @rtype: Pixbuf
        """
        return object
    
    def composite(self, dest=None, dest_x=None, dest_y=None, dest_width=None, dest_height=None, offset_x=None, offset_y=None, scale_x=None, scale_y=None, interp_type=None, overall_alpha=None):
        """        Creates a transformation of the source image @src by scaling by
        @scale_x and @scale_y then translating by @offset_x and @offset_y.
        This gives an image in the coordinates of the destination pixbuf.
        The rectangle (@dest_x, @dest_y, @dest_width, @dest_height)
        is then alpha blended onto the corresponding rectangle of the
        original destination image.
        
        When the destination rectangle contains parts not in the source
        image, the data at the edges of the source image is replicated
        to infinity.
        
        ![](composite.png)
        @param dest: the #GdkPixbuf into which to render the results
        @param dest_x: the left coordinate for region to render
        @param dest_y: the top coordinate for region to render
        @param dest_width: the width of the region to render
        @param dest_height: the height of the region to render
        @param offset_x: the offset in the X direction (currently rounded to an integer)
        @param offset_y: the offset in the Y direction (currently rounded to an integer)
        @param scale_x: the scale factor in the X direction
        @param scale_y: the scale factor in the Y direction
        @param interp_type: the interpolation type for the transformation.
        @param overall_alpha: overall alpha for source image (0..255)
        @type dest: Pixbuf
        @type dest_x: int
        @type dest_y: int
        @type dest_width: int
        @type dest_height: int
        @type offset_x: float
        @type offset_y: float
        @type scale_x: float
        @type scale_y: float
        @type interp_type: InterpType
        @type overall_alpha: int
        @returns: 
        @rtype: None
        """
        return object
    
    def composite_color(self, dest=None, dest_x=None, dest_y=None, dest_width=None, dest_height=None, offset_x=None, offset_y=None, scale_x=None, scale_y=None, interp_type=None, overall_alpha=None, check_x=None, check_y=None, check_size=None, color1=None, color2=None):
        """        Creates a transformation of the source image @src by scaling by
        @scale_x and @scale_y then translating by @offset_x and @offset_y,
        then alpha blends the rectangle (@dest_x ,@dest_y, @dest_width,
        @dest_height) of the resulting image with a checkboard of the
        colors @color1 and @color2 and renders it onto the destination
        image.
        
        If the source image has no alpha channel, and @overall_alpha is 255, a fast
        path is used which omits the alpha blending and just performs the scaling.
        
        See gdk_pixbuf_composite_color_simple() for a simpler variant of this
        function suitable for many tasks.
        @param dest: the #GdkPixbuf into which to render the results
        @param dest_x: the left coordinate for region to render
        @param dest_y: the top coordinate for region to render
        @param dest_width: the width of the region to render
        @param dest_height: the height of the region to render
        @param offset_x: the offset in the X direction (currently rounded to an integer)
        @param offset_y: the offset in the Y direction (currently rounded to an integer)
        @param scale_x: the scale factor in the X direction
        @param scale_y: the scale factor in the Y direction
        @param interp_type: the interpolation type for the transformation.
        @param overall_alpha: overall alpha for source image (0..255)
        @param check_x: the X offset for the checkboard (origin of checkboard is at -@check_x, -@check_y)
        @param check_y: the Y offset for the checkboard
        @param check_size: the size of checks in the checkboard (must be a power of two)
        @param color1: the color of check at upper left
        @param color2: the color of the other check
        @type dest: Pixbuf
        @type dest_x: int
        @type dest_y: int
        @type dest_width: int
        @type dest_height: int
        @type offset_x: float
        @type offset_y: float
        @type scale_x: float
        @type scale_y: float
        @type interp_type: InterpType
        @type overall_alpha: int
        @type check_x: int
        @type check_y: int
        @type check_size: int
        @type color1: guint32
        @type color2: guint32
        @returns: 
        @rtype: None
        """
        return object
    
    def composite_color_simple(self, dest_width=None, dest_height=None, interp_type=None, overall_alpha=None, check_size=None, color1=None, color2=None):
        """        Creates a new #GdkPixbuf by scaling @src to @dest_width x
        @dest_height and alpha blending the result with a checkboard of colors
        @color1 and @color2.
        @param dest_width: the width of destination image
        @param dest_height: the height of destination image
        @param interp_type: the interpolation type for the transformation.
        @param overall_alpha: overall alpha for source image (0..255)
        @param check_size: the size of checks in the checkboard (must be a power of two)
        @param color1: the color of check at upper left
        @param color2: the color of the other check
        @type dest_width: int
        @type dest_height: int
        @type interp_type: InterpType
        @type overall_alpha: int
        @type check_size: int
        @type color1: guint32
        @type color2: guint32
        @returns: the new #GdkPixbuf, or %NULL if not enough memory could be allocated for it.
        @rtype: Pixbuf
        """
        return object
    
    def copy(self):
        """        Creates a new #GdkPixbuf with a copy of the information in the specified
        @pixbuf. Note that this does not copy the options set on the original #GdkPixbuf,
        use gdk_pixbuf_copy_options() for this.
        @returns: A newly-created pixbuf with a reference count of 1, or %NULL if not enough memory could be allocated.
        @rtype: Pixbuf
        """
        return object
    
    def copy_area(self, src_x=None, src_y=None, width=None, height=None, dest_pixbuf=None, dest_x=None, dest_y=None):
        """        Copies a rectangular area from @src_pixbuf to @dest_pixbuf.  Conversion of
        pixbuf formats is done automatically.
        
        If the source rectangle overlaps the destination rectangle on the
        same pixbuf, it will be overwritten during the copy operation.
        Therefore, you can not use this function to scroll a pixbuf.
        @param src_x: Source X coordinate within @src_pixbuf.
        @param src_y: Source Y coordinate within @src_pixbuf.
        @param width: Width of the area to copy.
        @param height: Height of the area to copy.
        @param dest_pixbuf: Destination pixbuf.
        @param dest_x: X coordinate within @dest_pixbuf.
        @param dest_y: Y coordinate within @dest_pixbuf.
        @type src_x: int
        @type src_y: int
        @type width: int
        @type height: int
        @type dest_pixbuf: Pixbuf
        @type dest_x: int
        @type dest_y: int
        @returns: 
        @rtype: None
        """
        return object
    
    def copy_options(self, dest_pixbuf=None):
        """        Copy the key/value pair options attached to a #GdkPixbuf to another.
        This is useful to keep original metadata after having manipulated
        a file. However be careful to remove metadata which you've already
        applied, such as the "orientation" option after rotating the image.
        @param dest_pixbuf: the #GdkPixbuf to copy options to
        @type dest_pixbuf: Pixbuf
        @returns: %TRUE on success.
        @rtype: bool
        """
        return object
    
    def fill(self, pixel=None):
        """        Clears a pixbuf to the given RGBA value, converting the RGBA value into
        the pixbuf's pixel format. The alpha will be ignored if the pixbuf
        doesn't have an alpha channel.
        @param pixel: RGBA pixel to clear to         (0xffffffff is opaque white, 0x00000000 transparent black)
        @type pixel: guint32
        @returns: 
        @rtype: None
        """
        return object
    
    def flip(self, horizontal=None):
        """        Flips a pixbuf horizontally or vertically and returns the
        result in a new pixbuf.
        @param horizontal: %TRUE to flip horizontally, %FALSE to flip vertically
        @type horizontal: bool
        @returns: the new #GdkPixbuf, or %NULL if not enough memory could be allocated for it.
        @rtype: Pixbuf
        """
        return object
    
    def get_bits_per_sample(self):
        """        Queries the number of bits per color sample in a pixbuf.
        @returns: Number of bits per color sample.
        @rtype: int
        """
        return object
    
    def get_byte_length(self):
        """        Returns the length of the pixel data, in bytes.
        @returns: The length of the pixel data.
        @rtype: gsize
        """
        return object
    
    def get_colorspace(self):
        """        Queries the color space of a pixbuf.
        @returns: Color space.
        @rtype: Colorspace
        """
        return object
    
    def get_has_alpha(self):
        """        Queries whether a pixbuf has an alpha channel (opacity information).
        @returns: %TRUE if it has an alpha channel, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def get_height(self):
        """        Queries the height of a pixbuf.
        @returns: Height in pixels.
        @rtype: int
        """
        return object
    
    def get_n_channels(self):
        """        Queries the number of channels of a pixbuf.
        @returns: Number of channels.
        @rtype: int
        """
        return object
    
    def get_option(self, key=None):
        """        Looks up @key in the list of options that may have been attached to the
        @pixbuf when it was loaded, or that may have been attached by another
        function using gdk_pixbuf_set_option().
        
        For instance, the ANI loader provides "Title" and "Artist" options.
        The ICO, XBM, and XPM loaders provide "x_hot" and "y_hot" hot-spot
        options for cursor definitions. The PNG loader provides the tEXt ancillary
        chunk key/value pairs as options. Since 2.12, the TIFF and JPEG loaders
        return an "orientation" option string that corresponds to the embedded
        TIFF/Exif orientation tag (if present). Since 2.32, the TIFF loader sets
        the "multipage" option string to "yes" when a multi-page TIFF is loaded.
        Since 2.32 the JPEG and PNG loaders set "x-dpi" and "y-dpi" if the file
        contains image density information in dots per inch.
        Since 2.36.6, the JPEG loader sets the "comment" option with the comment
        EXIF tag.
        @param key: a nul-terminated string.
        @type key: str
        @returns: the value associated with @key. This is a nul-terminated string that should not be freed or %NULL if @key was not found.
        @rtype: str
        """
        return object
    
    def get_options(self):
        """        Returns a #GHashTable with a list of all the options that may have been
        attached to the @pixbuf when it was loaded, or that may have been
        attached by another function using gdk_pixbuf_set_option().
        
        See gdk_pixbuf_get_option() for more details.
        @returns: a #GHashTable of key/values
        @rtype: GLib.HashTable
        """
        return object
    
    def get_pixels(self):
        """        Queries a pointer to the pixel data of a pixbuf.
        @rtype: None
        """
        return object
    
    def get_pixels_with_length(self, length=None):
        """        Queries a pointer to the pixel data of a pixbuf.
        @param length: The length of the binary data.
        @type length: int
        @rtype: None
        """
        return object
    
    def get_rowstride(self):
        """        Queries the rowstride of a pixbuf, which is the number of bytes between
        the start of a row and the start of the next row.
        @returns: Distance between row starts.
        @rtype: int
        """
        return object
    
    def get_width(self):
        """        Queries the width of a pixbuf.
        @returns: Width in pixels.
        @rtype: int
        """
        return object
    
    def new_subpixbuf(self, src_x=None, src_y=None, width=None, height=None):
        """        Creates a new pixbuf which represents a sub-region of @src_pixbuf.
        The new pixbuf shares its pixels with the original pixbuf, so
        writing to one affects both.  The new pixbuf holds a reference to
        @src_pixbuf, so @src_pixbuf will not be finalized until the new
        pixbuf is finalized.
        
        Note that if @src_pixbuf is read-only, this function will force it
        to be mutable.
        @param src_x: X coord in @src_pixbuf
        @param src_y: Y coord in @src_pixbuf
        @param width: width of region in @src_pixbuf
        @param height: height of region in @src_pixbuf
        @type src_x: int
        @type src_y: int
        @type width: int
        @type height: int
        @returns: a new pixbuf
        @rtype: Pixbuf
        """
        return object
    
    def read_pixel_bytes(self):
        """        
        @returns: A new reference to a read-only copy of the pixel data.  Note that for mutable pixbufs, this function will incur a one-time copy of the pixel data for conversion into the returned #GBytes.
        @rtype: GLib.Bytes
        """
        return object
    
    def read_pixels(self):
        """        Returns a read-only pointer to the raw pixel data; must not be
        modified.  This function allows skipping the implicit copy that
        must be made if gdk_pixbuf_get_pixels() is called on a read-only
        pixbuf.
        @returns: 
        @rtype: guint8
        """
        return object
    
    def ref(self):
        """        Adds a reference to a pixbuf.
        @returns: The same as the @pixbuf argument.
        @rtype: Pixbuf
        """
        return object
    
    def remove_option(self, key=None):
        """        Remove the key/value pair option attached to a #GdkPixbuf.
        @param key: a nul-terminated string representing the key to remove.
        @type key: str
        @returns: %TRUE if an option was removed, %FALSE if not.
        @rtype: bool
        """
        return object
    
    def rotate_simple(self, angle=None):
        """        Rotates a pixbuf by a multiple of 90 degrees, and returns the
        result in a new pixbuf.
        
        If @angle is 0, a copy of @src is returned, avoiding any rotation.
        @param angle: the angle to rotate by
        @type angle: PixbufRotation
        @returns: the new #GdkPixbuf, or %NULL if not enough memory could be allocated for it.
        @rtype: Pixbuf
        """
        return object
    
    def saturate_and_pixelate(self, dest=None, saturation=None, pixelate=None):
        """        Modifies saturation and optionally pixelates @src, placing the result in
        @dest. @src and @dest may be the same pixbuf with no ill effects.  If
        @saturation is 1.0 then saturation is not changed. If it's less than 1.0,
        saturation is reduced (the image turns toward grayscale); if greater than
        1.0, saturation is increased (the image gets more vivid colors). If @pixelate
        is %TRUE, then pixels are faded in a checkerboard pattern to create a
        pixelated image. @src and @dest must have the same image format, size, and
        rowstride.
        @param dest: place to write modified version of @src
        @param saturation: saturation factor
        @param pixelate: whether to pixelate
        @type dest: Pixbuf
        @type saturation: float
        @type pixelate: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def save(self, filename=None, type=None, error=None, *args):
        """        Saves pixbuf to a file in format @type. By default, "jpeg", "png", "ico"
        and "bmp" are possible file formats to save in, but more formats may be
        installed. The list of all writable formats can be determined in the
        following way:
        
        |[
        void add_if_writable (GdkPixbufFormat *data, GSList **list)
        {
          if (gdk_pixbuf_format_is_writable (data))
            *list = g_slist_prepend (*list, data);
        }
        
        GSList *formats = gdk_pixbuf_get_formats ();
        GSList *writable_formats = NULL;
        g_slist_foreach (formats, add_if_writable, &writable_formats);
        g_slist_free (formats);
        ]|
        
        If @error is set, %FALSE will be returned. Possible errors include
        those in the #GDK_PIXBUF_ERROR domain and those in the #G_FILE_ERROR domain.
        
        The variable argument list should be %NULL-terminated; if not empty,
        it should contain pairs of strings that modify the save
        parameters. For example:
        |[
        gdk_pixbuf_save (pixbuf, handle, "jpeg", &error, "quality", "100", NULL);
        ]|
        
        Currently only few parameters exist. JPEG images can be saved with a
        "quality" parameter; its value should be in the range [0,100]. JPEG
        and PNG density can be set by setting the "x-dpi" and "y-dpi" parameters
        to the appropriate values in dots per inch.
        
        Text chunks can be attached to PNG images by specifying parameters of
        the form "tEXt::key", where key is an ASCII string of length 1-79.
        The values are UTF-8 encoded strings. The PNG compression level can
        be specified using the "compression" parameter; it's value is in an
        integer in the range of [0,9].
        
        ICC color profiles can also be embedded into PNG, JPEG and TIFF images.
        The "icc-profile" value should be the complete ICC profile encoded
        into base64.
        
        |[
        gchar *contents;
        gchar *contents_encode;
        gsize length;
        g_file_get_contents ("/home/hughsie/.color/icc/L225W.icm", &contents, &length, NULL);
        contents_encode = g_base64_encode ((const guchar *) contents, length);
        gdk_pixbuf_save (pixbuf, handle, "png", &error, "icc-profile", contents_encode, NULL);
        ]|
        
        TIFF images recognize: (1) a "bits-per-sample" option (integer) which
        can be either 1 for saving bi-level CCITTFAX4 images, or 8 for saving
        8-bits per sample; (2) a "compression" option (integer) which can be
        1 for no compression, 2 for Huffman, 5 for LZW, 7 for JPEG and 8 for
        DEFLATE (see the libtiff documentation and tiff.h for all supported
        codec values); (3) an "icc-profile" option (zero-terminated string)
        containing a base64 encoded ICC color profile.
        
        ICO images can be saved in depth 16, 24, or 32, by using the "depth"
        parameter. When the ICO saver is given "x_hot" and "y_hot" parameters,
        it produces a CUR instead of an ICO.
        @param filename: name of file to save.
        @param type: name of file format.
        @param error: return location for error, or %NULL
        @param *args: list of key-value save options, followed by %NULL
        @type filename: str
        @type type: str
        @type error: GLib.Error
        @returns: whether an error was set
        @rtype: bool
        """
        return object
    
    def save_to_buffer(self, buffer=None, buffer_size=None, type=None, error=None, *args):
        """        Saves pixbuf to a new buffer in format @type, which is currently "jpeg",
        "png", "tiff", "ico" or "bmp".  This is a convenience function that uses
        gdk_pixbuf_save_to_callback() to do the real work. Note that the buffer
        is not nul-terminated and may contain embedded  nuls.
        If @error is set, %FALSE will be returned and @buffer will be set to
        %NULL. Possible errors include those in the #GDK_PIXBUF_ERROR
        domain.
        
        See gdk_pixbuf_save() for more details.
        @param buffer: location to receive a pointer   to the new buffer.
        @param buffer_size: location to receive the size of the new buffer.
        @param type: name of file format.
        @param error: return location for error, or %NULL
        @param *args: list of key-value save options
        @type buffer_size: gsize
        @type type: str
        @type error: GLib.Error
        @returns: whether an error was set
        @rtype: bool
        """
        return object
    
    def save_to_bufferv(self, buffer=None, buffer_size=None, type=None, option_keys=None, option_values=None):
        """        Saves pixbuf to a new buffer in format @type, which is currently "jpeg",
        "tiff", "png", "ico" or "bmp".  See gdk_pixbuf_save_to_buffer()
        for more details.
        @param buffer: location to receive a pointer to the new buffer.
        @param buffer_size: location to receive the size of the new buffer.
        @param type: name of file format.
        @param option_keys: name of options to set, %NULL-terminated
        @param option_values: values for named options
        @type buffer_size: gsize
        @type type: str
        @returns: whether an error was set
        @rtype: bool
        """
        return object
    
    def save_to_callback(self, save_func=None, user_data=None, type=None, error=None, *args):
        """        Saves pixbuf in format @type by feeding the produced data to a
        callback. Can be used when you want to store the image to something
        other than a file, such as an in-memory buffer or a socket.
        If @error is set, %FALSE will be returned. Possible errors
        include those in the #GDK_PIXBUF_ERROR domain and whatever the save
        function generates.
        
        See gdk_pixbuf_save() for more details.
        @param save_func: a function that is called to save each block of data that   the save routine generates.
        @param user_data: user data to pass to the save function.
        @param type: name of file format.
        @param error: return location for error, or %NULL
        @param *args: list of key-value save options
        @type save_func: PixbufSaveFunc
        @type user_data: gpointer
        @type type: str
        @type error: GLib.Error
        @returns: whether an error was set
        @rtype: bool
        """
        return object
    
    def save_to_callbackv(self, save_func=None, user_data=None, type=None, option_keys=None, option_values=None):
        """        Saves pixbuf to a callback in format @type, which is currently "jpeg",
        "png", "tiff", "ico" or "bmp".  If @error is set, %FALSE will be returned. See
        gdk_pixbuf_save_to_callback () for more details.
        @param save_func: a function that is called to save each block of data that   the save routine generates.
        @param user_data: user data to pass to the save function.
        @param type: name of file format.
        @param option_keys: name of options to set, %NULL-terminated
        @param option_values: values for named options
        @type save_func: PixbufSaveFunc
        @type user_data: gpointer
        @type type: str
        @returns: whether an error was set
        @rtype: bool
        """
        return object
    
    def save_to_stream(self, stream=None, type=None, cancellable=None, error=None, *args):
        """        Saves @pixbuf to an output stream.
        
        Supported file formats are currently "jpeg", "tiff", "png", "ico" or
        "bmp". See gdk_pixbuf_save_to_buffer() for more details.
        
        The @cancellable can be used to abort the operation from another
        thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED
        will be returned. Other possible errors are in the #GDK_PIXBUF_ERROR
        and %G_IO_ERROR domains.
        
        The stream is not closed.
        @param stream: a #GOutputStream to save the pixbuf to
        @param type: name of file format
        @param cancellable: optional #GCancellable object, %NULL to ignore
        @param error: return location for error, or %NULL
        @param *args: list of key-value save options
        @type stream: Gio.OutputStream
        @type type: str
        @type cancellable: Gio.Cancellable
        @type error: GLib.Error
        @returns: %TRUE if the pixbuf was saved successfully, %FALSE if an
     error was set.
        @rtype: bool
        """
        return object
    
    def save_to_stream_async(self, stream=None, type=None, cancellable=None, callback=None, user_data=None, *args):
        """        Saves @pixbuf to an output stream asynchronously.
        
        For more details see gdk_pixbuf_save_to_stream(), which is the synchronous
        version of this function.
        
        When the operation is finished, @callback will be called in the main thread.
        You can then call gdk_pixbuf_save_to_stream_finish() to get the result of the operation.
        @param stream: a #GOutputStream to which to save the pixbuf
        @param type: name of file format
        @param cancellable: optional #GCancellable object, %NULL to ignore
        @param callback: a #GAsyncReadyCallback to call when the pixbuf is saved
        @param user_data: the data to pass to the callback function
        @param *args: list of key-value save options
        @type stream: Gio.OutputStream
        @type type: str
        @type cancellable: Gio.Cancellable
        @type callback: Gio.AsyncReadyCallback
        @type user_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def save_to_streamv(self, stream=None, type=None, option_keys=None, option_values=None, cancellable=None):
        """        Saves @pixbuf to an output stream.
        
        Supported file formats are currently "jpeg", "tiff", "png", "ico" or
        "bmp". See gdk_pixbuf_save_to_stream() for more details.
        @param stream: a #GOutputStream to save the pixbuf to
        @param type: name of file format
        @param option_keys: name of options to set, %NULL-terminated
        @param option_values: values for named options
        @param cancellable: optional #GCancellable object, %NULL to ignore
        @type stream: Gio.OutputStream
        @type type: str
        @type cancellable: Gio.Cancellable
        @returns: %TRUE if the pixbuf was saved successfully, %FALSE if an
     error was set.
        @rtype: bool
        """
        return object
    
    def save_to_streamv_async(self, stream=None, type=None, option_keys=None, option_values=None, cancellable=None, callback=None, user_data=None):
        """        Saves @pixbuf to an output stream asynchronously.
        
        For more details see gdk_pixbuf_save_to_streamv(), which is the synchronous
        version of this function.
        
        When the operation is finished, @callback will be called in the main thread.
        You can then call gdk_pixbuf_save_to_stream_finish() to get the result of the operation.
        @param stream: a #GOutputStream to which to save the pixbuf
        @param type: name of file format
        @param option_keys: name of options to set, %NULL-terminated
        @param option_values: values for named options
        @param cancellable: optional #GCancellable object, %NULL to ignore
        @param callback: a #GAsyncReadyCallback to call when the pixbuf is saved
        @param user_data: the data to pass to the callback function
        @type stream: Gio.OutputStream
        @type type: str
        @type cancellable: Gio.Cancellable
        @type callback: Gio.AsyncReadyCallback
        @type user_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def savev(self, filename=None, type=None, option_keys=None, option_values=None):
        """        Saves pixbuf to a file in @type, which is currently "jpeg", "png", "tiff", "ico" or "bmp".
        If @error is set, %FALSE will be returned.
        See gdk_pixbuf_save () for more details.
        @param filename: name of file to save.
        @param type: name of file format.
        @param option_keys: name of options to set, %NULL-terminated
        @param option_values: values for named options
        @type filename: str
        @type type: str
        @returns: whether an error was set
        @rtype: bool
        """
        return object
    
    def scale(self, dest=None, dest_x=None, dest_y=None, dest_width=None, dest_height=None, offset_x=None, offset_y=None, scale_x=None, scale_y=None, interp_type=None):
        """        Creates a transformation of the source image @src by scaling by
        @scale_x and @scale_y then translating by @offset_x and @offset_y,
        then renders the rectangle (@dest_x, @dest_y, @dest_width,
        @dest_height) of the resulting image onto the destination image
        replacing the previous contents.
        
        Try to use gdk_pixbuf_scale_simple() first, this function is
        the industrial-strength power tool you can fall back to if
        gdk_pixbuf_scale_simple() isn't powerful enough.
        
        If the source rectangle overlaps the destination rectangle on the
        same pixbuf, it will be overwritten during the scaling which
        results in rendering artifacts.
        @param dest: the #GdkPixbuf into which to render the results
        @param dest_x: the left coordinate for region to render
        @param dest_y: the top coordinate for region to render
        @param dest_width: the width of the region to render
        @param dest_height: the height of the region to render
        @param offset_x: the offset in the X direction (currently rounded to an integer)
        @param offset_y: the offset in the Y direction (currently rounded to an integer)
        @param scale_x: the scale factor in the X direction
        @param scale_y: the scale factor in the Y direction
        @param interp_type: the interpolation type for the transformation.
        @type dest: Pixbuf
        @type dest_x: int
        @type dest_y: int
        @type dest_width: int
        @type dest_height: int
        @type offset_x: float
        @type offset_y: float
        @type scale_x: float
        @type scale_y: float
        @type interp_type: InterpType
        @returns: 
        @rtype: None
        """
        return object
    
    def scale_simple(self, dest_width=None, dest_height=None, interp_type=None):
        """        Create a new #GdkPixbuf containing a copy of @src scaled to
        @dest_width x @dest_height. Leaves @src unaffected.  @interp_type
        should be #GDK_INTERP_NEAREST if you want maximum speed (but when
        scaling down #GDK_INTERP_NEAREST is usually unusably ugly).  The
        default @interp_type should be #GDK_INTERP_BILINEAR which offers
        reasonable quality and speed.
        
        You can scale a sub-portion of @src by creating a sub-pixbuf
        pointing into @src; see gdk_pixbuf_new_subpixbuf().
        
        If @dest_width and @dest_height are equal to the @src width and height, a
        copy of @src is returned, avoiding any scaling.
        
        For more complicated scaling/alpha blending see gdk_pixbuf_scale()
        and gdk_pixbuf_composite().
        @param dest_width: the width of destination image
        @param dest_height: the height of destination image
        @param interp_type: the interpolation type for the transformation.
        @type dest_width: int
        @type dest_height: int
        @type interp_type: InterpType
        @returns: the new #GdkPixbuf, or %NULL if not enough memory could be allocated for it.
        @rtype: Pixbuf
        """
        return object
    
    def set_option(self, key=None, value=None):
        """        Attaches a key/value pair as an option to a #GdkPixbuf. If @key already
        exists in the list of options attached to @pixbuf, the new value is
        ignored and %FALSE is returned.
        @param key: a nul-terminated string.
        @param value: a nul-terminated string.
        @type key: str
        @type value: str
        @returns: %TRUE on success.
        @rtype: bool
        """
        return object
    
    def unref(self):
        """        Removes a reference from a pixbuf.
        @returns: 
        @rtype: None
        """
        return object


class PixbufAnimation(GObject.Object):
    """An opaque struct representing an animation."""
    @staticmethod
    def new_from_file(filename=None):
        """        Creates a new animation by loading it from a file. The file format is
        detected automatically. If the file's format does not support multi-frame
        images, then an animation with a single frame will be created. Possible errors
        are in the #GDK_PIXBUF_ERROR and #G_FILE_ERROR domains.
        @param filename: Name of file to load, in the GLib file name encoding
        @type filename: str
        @returns: Newly created PixbufAnimation
        @rtype: PixbufAnimation
        """
        return object
    @staticmethod
    def new_from_resource(resource_path=None):
        """        Creates a new pixbuf animation by loading an image from an resource.
        
        The file format is detected automatically. If %NULL is returned, then
        @error will be set.
        @param resource_path: the path of the resource file
        @type resource_path: str
        @returns: Newly created PixbufAnimation
        @rtype: PixbufAnimation
        """
        return object
    @staticmethod
    def new_from_stream(stream=None, cancellable=None):
        """        Creates a new animation by loading it from an input stream.
        
        The file format is detected automatically. If %NULL is returned, then
        @error will be set. The @cancellable can be used to abort the operation
        from another thread. If the operation was cancelled, the error
        %G_IO_ERROR_CANCELLED will be returned. Other possible errors are in
        the #GDK_PIXBUF_ERROR and %G_IO_ERROR domains.
        
        The stream is not closed.
        @param stream: a #GInputStream to load the pixbuf from
        @param cancellable: optional #GCancellable object, %NULL to ignore
        @type stream: Gio.InputStream
        @type cancellable: Gio.Cancellable
        @returns: Newly created PixbufAnimation
        @rtype: PixbufAnimation
        """
        return object
    @staticmethod
    def new_from_stream_finish(async_result=None):
        """        Finishes an asynchronous pixbuf animation creation operation started with
        gdk_pixbuf_animation_new_from_stream_async().
        @param async_result: a #GAsyncResult
        @type async_result: Gio.AsyncResult
        @returns: Newly created PixbufAnimation
        @rtype: PixbufAnimation
        """
        return object
    @staticmethod
    def new_from_stream_async(stream=None, cancellable=None, callback=None, user_data=None):
        """        Creates a new animation by asynchronously loading an image from an input stream.
        
        For more details see gdk_pixbuf_new_from_stream(), which is the synchronous
        version of this function.
        
        When the operation is finished, @callback will be called in the main thread.
        You can then call gdk_pixbuf_animation_new_from_stream_finish() to get the
        result of the operation.
        @param stream: a #GInputStream from which to load the animation
        @param cancellable: optional #GCancellable object, %NULL to ignore
        @param callback: a #GAsyncReadyCallback to call when the pixbuf is loaded
        @param user_data: the data to pass to the callback function
        @type stream: Gio.InputStream
        @type cancellable: Gio.Cancellable
        @type callback: Gio.AsyncReadyCallback
        @type user_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def get_height(self):
        """        Queries the height of the bounding box of a pixbuf animation.
        @returns: Height of the bounding box of the animation.
        @rtype: int
        """
        return object
    
    def get_iter(self, start_time=None):
        """        Get an iterator for displaying an animation. The iterator provides
        the frames that should be displayed at a given time. It should be
        freed after use with g_object_unref().
        
        @start_time would normally come from g_get_current_time(), and marks
        the beginning of animation playback. After creating an iterator, you
        should immediately display the pixbuf returned by
        gdk_pixbuf_animation_iter_get_pixbuf(). Then, you should install
        a timeout (with g_timeout_add()) or by some other mechanism ensure
        that you'll update the image after
        gdk_pixbuf_animation_iter_get_delay_time() milliseconds. Each time
        the image is updated, you should reinstall the timeout with the new,
        possibly-changed delay time.
        
        As a shortcut, if @start_time is %NULL, the result of
        g_get_current_time() will be used automatically.
        
        To update the image (i.e. possibly change the result of
        gdk_pixbuf_animation_iter_get_pixbuf() to a new frame of the animation),
        call gdk_pixbuf_animation_iter_advance().
        
        If you're using #GdkPixbufLoader, in addition to updating the image
        after the delay time, you should also update it whenever you
        receive the area_updated signal and
        gdk_pixbuf_animation_iter_on_currently_loading_frame() returns
        %TRUE. In this case, the frame currently being fed into the loader
        has received new data, so needs to be refreshed. The delay time for
        a frame may also be modified after an area_updated signal, for
        example if the delay time for a frame is encoded in the data after
        the frame itself. So your timeout should be reinstalled after any
        area_updated signal.
        
        A delay time of -1 is possible, indicating "infinite."
        @param start_time: time when the animation starts playing
        @type start_time: GLib.TimeVal
        @returns: an iterator to move over the animation
        @rtype: PixbufAnimationIter
        """
        return object
    
    def get_static_image(self):
        """        If an animation is really just a plain image (has only one frame),
        this function returns that image. If the animation is an animation,
        this function returns a reasonable thing to display as a static
        unanimated image, which might be the first frame, or something more
        sophisticated. If an animation hasn't loaded any frames yet, this
        function will return %NULL.
        @returns: unanimated image representing the animation
        @rtype: Pixbuf
        """
        return object
    
    def get_width(self):
        """        Queries the width of the bounding box of a pixbuf animation.
        @returns: Width of the bounding box of the animation.
        @rtype: int
        """
        return object
    
    def is_static_image(self):
        """        If you load a file with gdk_pixbuf_animation_new_from_file() and it
        turns out to be a plain, unanimated image, then this function will
        return %TRUE. Use gdk_pixbuf_animation_get_static_image() to retrieve
        the image.
        @returns: %TRUE if the "animation" was really just an image
        @rtype: bool
        """
        return object
    
    def ref(self):
        """        Adds a reference to an animation.
        @returns: The same as the @animation argument.
        @rtype: PixbufAnimation
        """
        return object
    
    def unref(self):
        """        Removes a reference from an animation.
        @returns: 
        @rtype: None
        """
        return object


class PixbufAnimationIter(GObject.Object):
    """An opaque struct representing an iterator which points to a
certain position in an animation."""
    
    def advance(self, current_time=None):
        """        Possibly advances an animation to a new frame. Chooses the frame based
        on the start time passed to gdk_pixbuf_animation_get_iter().
        
        @current_time would normally come from g_get_current_time(), and
        must be greater than or equal to the time passed to
        gdk_pixbuf_animation_get_iter(), and must increase or remain
        unchanged each time gdk_pixbuf_animation_iter_get_pixbuf() is
        called. That is, you can't go backward in time; animations only
        play forward.
        
        As a shortcut, pass %NULL for the current time and g_get_current_time()
        will be invoked on your behalf. So you only need to explicitly pass
        @current_time if you're doing something odd like playing the animation
        at double speed.
        
        If this function returns %FALSE, there's no need to update the animation
        display, assuming the display had been rendered prior to advancing;
        if %TRUE, you need to call gdk_pixbuf_animation_iter_get_pixbuf()
        and update the display with the new pixbuf.
        @param current_time: current time
        @type current_time: GLib.TimeVal
        @returns: %TRUE if the image may need updating
        @rtype: bool
        """
        return object
    
    def get_delay_time(self):
        """        Gets the number of milliseconds the current pixbuf should be displayed,
        or -1 if the current pixbuf should be displayed forever. g_timeout_add()
        conveniently takes a timeout in milliseconds, so you can use a timeout
        to schedule the next update.
        
        Note that some formats, like GIF, might clamp the timeout values in the
        image file to avoid updates that are just too quick. The minimum timeout
        for GIF images is currently 20 milliseconds.
        @returns: delay time in milliseconds (thousandths of a second)
        @rtype: int
        """
        return object
    
    def get_pixbuf(self):
        """        Gets the current pixbuf which should be displayed; the pixbuf might not
        be the same size as the animation itself
        (gdk_pixbuf_animation_get_width(), gdk_pixbuf_animation_get_height()).
        This pixbuf should be displayed for
        gdk_pixbuf_animation_iter_get_delay_time() milliseconds. The caller
        of this function does not own a reference to the returned pixbuf;
        the returned pixbuf will become invalid when the iterator advances
        to the next frame, which may happen anytime you call
        gdk_pixbuf_animation_iter_advance(). Copy the pixbuf to keep it
        (don't just add a reference), as it may get recycled as you advance
        the iterator.
        @returns: the pixbuf to be displayed
        @rtype: Pixbuf
        """
        return object
    
    def on_currently_loading_frame(self):
        """        Used to determine how to respond to the area_updated signal on
        #GdkPixbufLoader when loading an animation. area_updated is emitted
        for an area of the frame currently streaming in to the loader. So if
        you're on the currently loading frame, you need to redraw the screen for
        the updated area.
        @returns: %TRUE if the frame we're on is partially loaded, or the last frame
        @rtype: bool
        """
        return object


class PixbufFormat():
    """"""
    
    def copy(self):
        """        Creates a copy of @format
        @returns: the newly allocated copy of a #GdkPixbufFormat. Use
   gdk_pixbuf_format_free() to free the resources when done
        @rtype: PixbufFormat
        """
        return object
    
    def free(self):
        """        Frees the resources allocated when copying a #GdkPixbufFormat
        using gdk_pixbuf_format_copy()
        @returns: 
        @rtype: None
        """
        return object
    
    def get_description(self):
        """        Returns a description of the format.
        @returns: a description of the format.
        @rtype: str
        """
        return object
    
    def get_extensions(self):
        """        Returns the filename extensions typically used for files in the
        given format.
        @rtype: None
        """
        return object
    
    def get_license(self):
        """        Returns information about the license of the image loader for the format. The
        returned string should be a shorthand for a wellknown license, e.g. "LGPL",
        "GPL", "QPL", "GPL/QPL", or "other" to indicate some other license.  This
        string should be freed with g_free() when it's no longer needed.
        @returns: a string describing the license of @format.
        @rtype: str
        """
        return object
    
    def get_mime_types(self):
        """        Returns the mime types supported by the format.
        @rtype: None
        """
        return object
    
    def get_name(self):
        """        Returns the name of the format.
        @returns: the name of the format.
        @rtype: str
        """
        return object
    
    def is_disabled(self):
        """        Returns whether this image format is disabled. See
        gdk_pixbuf_format_set_disabled().
        @returns: whether this image format is disabled.
        @rtype: bool
        """
        return object
    
    def is_save_option_supported(self, option_key=None):
        """        Returns %TRUE if the save option specified by @option_key is supported when
        saving a pixbuf using the module implementing @format.
        See gdk_pixbuf_save() for more information about option keys.
        @param option_key: the name of an option
        @type option_key: str
        @returns: %TRUE if the specified option is supported
        @rtype: bool
        """
        return object
    
    def is_scalable(self):
        """        Returns whether this image format is scalable. If a file is in a
        scalable format, it is preferable to load it at the desired size,
        rather than loading it at the default size and scaling the
        resulting pixbuf to the desired size.
        @returns: whether this image format is scalable.
        @rtype: bool
        """
        return object
    
    def is_writable(self):
        """        Returns whether pixbufs can be saved in the given format.
        @returns: whether pixbufs can be saved in the given format.
        @rtype: bool
        """
        return object
    
    def set_disabled(self, disabled=None):
        """        Disables or enables an image format. If a format is disabled,
        gdk-pixbuf won't use the image loader for this format to load
        images. Applications can use this to avoid using image loaders
        with an inappropriate license, see gdk_pixbuf_format_get_license().
        @param disabled: %TRUE to disable the format @format
        @type disabled: bool
        @returns: 
        @rtype: None
        """
        return object


class PixbufLoader(GObject.Object):
    """The GdkPixbufLoader struct contains only private
fields."""
    
    def __init__(self):
        """        Creates a new pixbuf loader object.
        @returns: Newly created PixbufLoader
        @rtype: PixbufLoader
        """
        return object
    @staticmethod
    def new():
        """        Creates a new pixbuf loader object.
        @returns: Newly created PixbufLoader
        @rtype: PixbufLoader
        """
        return object
    @staticmethod
    def new_with_mime_type(mime_type=None):
        """        Creates a new pixbuf loader object that always attempts to parse
        image data as if it were an image of mime type @mime_type, instead of
        identifying the type automatically. Useful if you want an error if
        the image isn't the expected mime type, for loading image formats
        that can't be reliably identified by looking at the data, or if
        the user manually forces a specific mime type.
        
        The list of supported mime types depends on what image loaders
        are installed, but typically "image/png", "image/jpeg", "image/gif",
        "image/tiff" and "image/x-xpixmap" are among the supported mime types.
        To obtain the full list of supported mime types, call
        gdk_pixbuf_format_get_mime_types() on each of the #GdkPixbufFormat
        structs returned by gdk_pixbuf_get_formats().
        @param mime_type: the mime type to be loaded
        @type mime_type: str
        @returns: Newly created PixbufLoader
        @rtype: PixbufLoader
        """
        return object
    @staticmethod
    def new_with_type(image_type=None):
        """        Creates a new pixbuf loader object that always attempts to parse
        image data as if it were an image of type @image_type, instead of
        identifying the type automatically. Useful if you want an error if
        the image isn't the expected type, for loading image formats
        that can't be reliably identified by looking at the data, or if
        the user manually forces a specific type.
        
        The list of supported image formats depends on what image loaders
        are installed, but typically "png", "jpeg", "gif", "tiff" and
        "xpm" are among the supported formats. To obtain the full list of
        supported image formats, call gdk_pixbuf_format_get_name() on each
        of the #GdkPixbufFormat structs returned by gdk_pixbuf_get_formats().
        @param image_type: name of the image format to be loaded with the image
        @type image_type: str
        @returns: Newly created PixbufLoader
        @rtype: PixbufLoader
        """
        return object
    
    def area_prepared(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def area_updated(self, x=None, y=None, width=None, height=None):
        """        
        @type x: int
        @type y: int
        @type width: int
        @type height: int
        @returns: 
        @rtype: None
        """
        return object
    
    def closed(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def size_prepared(self, width=None, height=None):
        """        
        @type width: int
        @type height: int
        @returns: 
        @rtype: None
        """
        return object
    
    def close(self):
        """        Informs a pixbuf loader that no further writes with
        gdk_pixbuf_loader_write() will occur, so that it can free its
        internal loading structures. Also, tries to parse any data that
        hasn't yet been parsed; if the remaining data is partial or
        corrupt, an error will be returned.  If %FALSE is returned, @error
        will be set to an error from the #GDK_PIXBUF_ERROR or #G_FILE_ERROR
        domains. If you're just cancelling a load rather than expecting it
        to be finished, passing %NULL for @error to ignore it is
        reasonable.
        
        Remember that this does not unref the loader, so if you plan not to
        use it anymore, please g_object_unref() it.
        @returns: %TRUE if all image data written so far was successfully
             passed out via the update_area signal
        @rtype: bool
        """
        return object
    
    def get_animation(self):
        """        Queries the #GdkPixbufAnimation that a pixbuf loader is currently creating.
        In general it only makes sense to call this function after the "area-prepared"
        signal has been emitted by the loader. If the loader doesn't have enough
        bytes yet (hasn't emitted the "area-prepared" signal) this function will
        return %NULL.
        @returns: The #GdkPixbufAnimation that the loader is loading, or %NULL if not enough data has been read to determine the information.
        @rtype: PixbufAnimation
        """
        return object
    
    def get_format(self):
        """        Obtains the available information about the format of the
        currently loading image file.
        @returns: A #GdkPixbufFormat or %NULL. The return value is owned by GdkPixbuf and should not be freed.
        @rtype: PixbufFormat
        """
        return object
    
    def get_pixbuf(self):
        """        Queries the #GdkPixbuf that a pixbuf loader is currently creating.
        In general it only makes sense to call this function after the
        "area-prepared" signal has been emitted by the loader; this means
        that enough data has been read to know the size of the image that
        will be allocated.  If the loader has not received enough data via
        gdk_pixbuf_loader_write(), then this function returns %NULL.  The
        returned pixbuf will be the same in all future calls to the loader,
        so simply calling g_object_ref() should be sufficient to continue
        using it.  Additionally, if the loader is an animation, it will
        return the "static image" of the animation
        (see gdk_pixbuf_animation_get_static_image()).
        @returns: The #GdkPixbuf that the loader is creating, or %NULL if not enough data has been read to determine how to create the image buffer.
        @rtype: Pixbuf
        """
        return object
    
    def set_size(self, width=None, height=None):
        """        Causes the image to be scaled while it is loaded. The desired
        image size can be determined relative to the original size of
        the image by calling gdk_pixbuf_loader_set_size() from a
        signal handler for the ::size-prepared signal.
        
        Attempts to set the desired image size  are ignored after the
        emission of the ::size-prepared signal.
        @param width: The desired width of the image being loaded.
        @param height: The desired height of the image being loaded.
        @type width: int
        @type height: int
        @returns: 
        @rtype: None
        """
        return object
    
    def write(self, buf=None, count=None):
        """        This will cause a pixbuf loader to parse the next @count bytes of
        an image.  It will return %TRUE if the data was loaded successfully,
        and %FALSE if an error occurred.  In the latter case, the loader
        will be closed, and will not accept further writes. If %FALSE is
        returned, @error will be set to an error from the #GDK_PIXBUF_ERROR
        or #G_FILE_ERROR domains.
        @param buf: Pointer to image data.
        @param count: Length of the @buf buffer in bytes.
        @type count: gsize
        @returns: %TRUE if the write was successful, or %FALSE if the loader cannot parse the buffer.
        @rtype: bool
        """
        return object
    
    def write_bytes(self, buffer=None):
        """        This will cause a pixbuf loader to parse a buffer inside a #GBytes
        for an image.  It will return %TRUE if the data was loaded successfully,
        and %FALSE if an error occurred.  In the latter case, the loader
        will be closed, and will not accept further writes. If %FALSE is
        returned, @error will be set to an error from the #GDK_PIXBUF_ERROR
        or #G_FILE_ERROR domains.
        
        See also: gdk_pixbuf_loader_write()
        @param buffer: The image data as a #GBytes
        @type buffer: GLib.Bytes
        @returns: %TRUE if the write was successful, or %FALSE if the loader cannot parse the buffer.
        @rtype: bool
        """
        return object

    @property
    def parent_instance(self):
        return object

    @property
    def priv(self):
        return object


class PixbufLoaderClass():
    """"""

    @property
    def parent_class(self):
        return object

    @property
    def size_prepared(self):
        return object

    @property
    def area_prepared(self):
        return object

    @property
    def area_updated(self):
        return object

    @property
    def closed(self):
        return object


class PixbufSimpleAnim(PixbufAnimation):
    """An opaque struct representing a simple animation."""
    
    def __init__(self, width=None, height=None, rate=None):
        """        Creates a new, empty animation.
        @param width: the width of the animation
        @param height: the height of the animation
        @param rate: the speed of the animation, in frames per second
        @type width: int
        @type height: int
        @type rate: float
        @returns: Newly created PixbufSimpleAnim
        @rtype: PixbufSimpleAnim
        """
        return object
    @staticmethod
    def new(width=None, height=None, rate=None):
        """        Creates a new, empty animation.
        @param width: the width of the animation
        @param height: the height of the animation
        @param rate: the speed of the animation, in frames per second
        @type width: int
        @type height: int
        @type rate: float
        @returns: Newly created PixbufSimpleAnim
        @rtype: PixbufSimpleAnim
        """
        return object
    
    def add_frame(self, pixbuf=None):
        """        Adds a new frame to @animation. The @pixbuf must
        have the dimensions specified when the animation
        was constructed.
        @param pixbuf: the pixbuf to add
        @type pixbuf: Pixbuf
        @returns: 
        @rtype: None
        """
        return object
    
    def get_loop(self):
        """        Gets whether @animation should loop indefinitely when it reaches the end.
        @returns: %TRUE if the animation loops forever, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def set_loop(self, loop=None):
        """        Sets whether @animation should loop indefinitely when it reaches the end.
        @param loop: whether to loop the animation
        @type loop: bool
        @returns: 
        @rtype: None
        """
        return object


class PixbufSimpleAnimClass():
    """"""


class PixbufSimpleAnimIter(PixbufAnimationIter):
    """"""


class Pixdata():
    """A #GdkPixdata contains pixbuf information in a form suitable for
serialization and streaming."""
    
    def deserialize(self, stream_length=None, stream=None):
        """        Deserializes (reconstruct) a #GdkPixdata structure from a byte stream.
        The byte stream consists of a straightforward writeout of the
        #GdkPixdata fields in network byte order, plus the @pixel_data
        bytes the structure points to.
        The @pixdata contents are reconstructed byte by byte and are checked
        for validity. This function may fail with %GDK_PIXBUF_ERROR_CORRUPT_IMAGE
        or %GDK_PIXBUF_ERROR_UNKNOWN_TYPE.
        @param stream_length: length of the stream used for deserialization.
        @param stream: stream of bytes containing a   serialized #GdkPixdata structure.
        @type stream_length: int
        @returns: Upon successful deserialization %TRUE is returned, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def from_pixbuf(self, pixbuf=None, use_rle=None):
        """        Converts a #GdkPixbuf to a #GdkPixdata. If @use_rle is %TRUE, the
        pixel data is run-length encoded into newly-allocated memory and a
        pointer to that memory is returned.
        @param pixbuf: the data to fill @pixdata with.
        @param use_rle: whether to use run-length encoding for the pixel data.
        @type pixbuf: Pixbuf
        @type use_rle: bool
        @returns: If @use_rle is %TRUE, a pointer to the
   newly-allocated memory for the run-length encoded pixel data,
   otherwise %NULL.
        @rtype: gpointer
        """
        return object
    
    def serialize(self, stream_length_p=None):
        """        Serializes a #GdkPixdata structure into a byte stream.
        The byte stream consists of a straightforward writeout of the
        #GdkPixdata fields in network byte order, plus the @pixel_data
        bytes the structure points to.
        @param stream_length_p: location to store the resulting stream length in.
        @type stream_length_p: int
        @rtype: None
        """
        return object
    
    def to_csource(self, name=None, dump_type=None):
        """        Generates C source code suitable for compiling images directly
        into programs.
        
        gdk-pixbuf ships with a program called
        [gdk-pixbuf-csource][gdk-pixbuf-csource], which offers a command
        line interface to this function.
        @param name: used for naming generated data structures or macros.
        @param dump_type: a #GdkPixdataDumpType determining the kind of C   source to be generated.
        @type name: str
        @type dump_type: PixdataDumpType
        @returns: a newly-allocated string containing the C source form
   of @pixdata.
        @rtype: GLib.String
        """
        return object

    @property
    def magic(self):
        return object

    @property
    def length(self):
        return object

    @property
    def pixdata_type(self):
        return object

    @property
    def rowstride(self):
        return object

    @property
    def width(self):
        return object

    @property
    def height(self):
        return object

    @property
    def pixel_data(self):
        return object
